Media streaming using an index file

ABSTRACT

The present disclosure relates to playback of video/audio streaming media data to provide a substantially glitch-free experience. The system adapts the media stream to the user connection in order to choose the most desirable stream to avoid glitches. For example, in the case where there is interference (e.g., a microwave being used near a wireless device), the quality of the media stream is lowered. In one embodiment, an index file is used to make logical decisions about which media stream to choose in order to minimize glitches. The index file can take different forms, but, generally, includes characteristics about the available media streams. Example characteristics include the bit rates of the media streams and quality information about the media streams.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. Provisional Patent Application No. 61/057,759, filed on May 30, 2008, and U.S. Provisional Patent Application No. 61/057,755, filed May 30, 2008. Both applications are hereby incorporated in their entirety.

BACKGROUND

With the increasing popularity of playing streaming audio and video over networks such as the Internet, there is a need for optimizing the data transferred from a server to a client such that the client's experience is maximized even if network conditions during playback are inconsistent. Optimizing the client's experience involves making encoding decisions such that the video can be transferred and reconstructed with a minimal number of errors.

The term “streaming” is typically used to indicate that the data representing the media is provided by a host computer over a network to a playback device (i.e., a media playback computer implemented as any of a variety of conventional computing devices, such as a desktop PC, a notebook or portable computer a cellular telephone or other wireless communication device, a personal digital assistant (PDA), a gaming console, etc.) The client computer typically renders the streaming content as it is received from the host, rather than waiting for the entire file to be delivered.

The quality level is generally dictated by the bit rate specified for the encoded audio or video portions of the input stream. A higher bit rate generally indicates that a larger amount of information about the original audio or video is encoded and retained, and therefore a more accurate reproduction of the original input audio or video can be presented during video playback. Conversely, a lower bit rate indicates that less information about the original input audio or video is encoded and retained, and thus a less accurate reproduction of the original audio or video will be presented during video playback.

Generally, the bit rate is specified for encoding each of the audio and video based on several factors. The first factor is the network condition between the server and the client. A network connection that can transfer a high amount of data indicates that a higher bit rate can be specified for the input video that is subsequently transferred over the network connection. The second factor is the desired start-up latency. Start-up latency is the delay that a video playback tool experiences when first starting up due to the large amount of data that has to be received, processed, and buffered. Start-up latency can also occur after a seek operation, where the user selects variable positions in the streaming content to view. A third factor is the processing capabilities of the playback device. The fourth factor is the tolerance to glitching. Glitching occurs when the content is not displayed at the rate it was authored causing the playback device to run out of data to display. In most cases any amount of start-up latency or glitching is intolerable, and it is therefore desirable to optimize the bit rate specified such that the start-up latency and the glitching are minimized or eliminated.

SUMMARY

The present disclosure relates to playback of video/audio streaming media data to provide a substantially glitch-free experience. The system adapts the media stream to the user connection in order to choose the most desirable stream to avoid glitches. For example, in the case where there is interference (e.g., a microwave being used near a wireless device), the quality of the media stream is lowered.

In one embodiment, an index file is used to make logical decisions about which media stream to choose in order to minimize glitches. The index file can take different forms, but, generally, includes characteristics about the available media streams. Example characteristics include the bit rates of the media streams and quality information about the media streams.

The foregoing and other objects, features, and advantages of the invention will become more apparent from the following detailed description, which proceeds with reference to the accompanying figures.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 illustrates an exemplary environment suitable for sending streaming media content over a network from a host device to a playback device.

FIG. 2 illustrates an example encoder on the host device.

FIG. 3 illustrates example media streams having the same content at different fixed bit rates.

FIG. 4 illustrates an example media streams having the same content at variable bit rates.

FIG. 5 is a flowchart of a method for encoding multiple media streams and generating an associated index table.

FIG. 6 illustrates an example application for rendering streaming media content on the playback device wherein a heuristics module is in the same application as a media pipeline.

FIG. 7 illustrates an example application for rendering streaming media content on the playback device wherein the media pipeline is in a platform and the heuristics module is in a downloadable (e.g., plug-in) program.

FIG. 8 illustrates an exemplary computing environment.

FIG. 9 illustrates an exemplary media pipeline on the playback device.

FIG. 10 illustrates a detailed view of an index file used by the playback device.

FIG. 11 is a flowchart of a method for using an index file to make logical decisions about which media stream to retrieve from the network.

FIG. 12 is a flowchart of a method for using both buffer level and quality in determining which media stream to download from a server.

FIG. 13 is a flowchart of a method for dynamically modifying the quality level in determining which media stream to download from a server.

FIG. 14 is a detailed flowchart of a method for dynamically modifying quality.

FIG. 15 is a flowchart for determining a media stream to render using buffer levels.

FIG. 16 is an example of a buffer level verses time graph with specific levels shown.

DETAILED DESCRIPTION

As used in this application and in the claims, the singular forms “a,” “an” and “the” include the plural forms unless the context clearly dictates otherwise. Additionally, the term “includes” means “comprises.” Although the operations of some of the disclosed methods and apparatus are described in a particular, sequential order for convenient presentation, it should be understood that this manner of description encompasses rearrangement, unless a particular ordering is required by specific language set forth below. For example, operations described sequentially can in some cases be rearranged or performed concurrently.

Any of the methods described herein can be performed (at least in part) using software comprising computer-executable instructions stored on one or more computer-readable media. Furthermore, any intermediate or final results of the disclosed methods can be stored on one or more computer-readable media. It should be understood that the disclosed technology is not limited to any specific computer language, program, or computer. For instance, a wide variety of commercially available computer languages, programs, and computers can be used.

FIG. 1 illustrates an exemplary environment 100, which can be suitable for transmitting media content being streamed over a network 106 from a host computer device 102 to a playback computer device 104. The network 106 can be any of a variety of conventional network topologies and types (including optical, wired and/or wireless networks), using a variety of conventional network protocols (including public and/or proprietary protocols). The network 106 can include, for example, a home network, a corporate network, or the Internet, as well as possibly at least portions of one or more local area networks (LANs) and/or wide area networks (WANs) or telephone networks.

A host device 102 generally stores media content and streams media content to the playback device 104. The playback device 104 can receive streaming media content via the network 106 from host device 102 and plays it for a user. Additionally, the playback device 102 can request a desired bit rate from the host device, which offers multiple bit rates to download. Host device 102 may be implemented as any of a variety of conventional computing devices, including, for example, a desktop PC, a notebook or portable computer, a workstation, an Internet appliance, and combinations thereof. Playback device 104 may also be implemented as any of a variety of conventional computing devices, including, for example, a desktop PC, a notebook or portable computer, a workstation, an Internet appliance, a gaming console, a handheld PC, a cellular telephone or other wireless communications device, a personal digital assistant (PDA), a set-top box, and combinations thereof.

Host device 102 can make any of a variety of data available for streaming to playback device 104, including content, such as audio, video, text, images, animation, and the like. However, as used herein with respect to the exemplary embodiments described below, media content is intended to represent audio/video (A/V) content or just video content. Furthermore, references made herein to “media content”, “streaming media”, “streaming video”, “video content”, and any variation thereof are generally intended to include audio/video content. The term “streaming” is used to indicate that the data representing the media content is provided over a network 106 to a playback device 104 and that playback of the content can begin prior to the content being delivered in its entirety.

FIG. 2 illustrates an exemplary encoding tool 200 that can be implemented on the host device 102. The tool includes a segmenter 210 that accepts input video 205 and splits the input video into a plurality of segments each comprising a certain number of frames. Input video generally refers to a stream comprising both audio components and video components. In certain embodiments, the segments each comprise 60 frames. In other embodiments the segments can vary across a range of values such as comprising between 30 frames to 90 frames. The number of frames in the segment can be based on factors such as scene changes in the input video 205. For example, if a segment contains a scene change, the frames before the scene change could be drastically different than the frames after the scene change.

The segmenter 210 outputs the segments to a bit rate controller 215. The bit rate controller 215 analyzes each segment and selects bit rates for one or more bit rate layers for each of the segments. A bit rate layer is a layer comprising a specific bit rate used to encode the input video 205. The number of bit rate layers and their respective bit rates for each segment may be affected by factors associated with the segment, such as the number of frames in the segment or the complexity of the input video 205 in the given segment. Additionally, the number of bit rate layers and their corresponding bit rates may be affected by factors not associated with the given segment, such as limits on the size of the file or the maximum or minimum bandwidth of the network that the encoded input video 205 will be transferred through. In one embodiment, the bit rate controller 215 selects the bit rates for the bit rate layers, for each of the segments independently from each of the other segments. Thus, a given segment may be encoded at the same or different bit rates as any other segment.

The segmenter 210 also outputs the segments to an encoder 220, and the bit rate controller 215 signals the bit rate layers for each segment to the encoder 220. The encoder 220 can encode according to a Windows Media Video or VC-1 format, MPEG-x format (e.g., MPEG-1, MPEG-2, or MPEG-4), H.26x format (e.g., H.261, H.262, H.263, or H.264), or other format. The encoder 220 may also be able to encode according to one or more audio standards such as WAV, FLAC, MP3, WMA, or some other standard. In some embodiments the encoder 220 encodes each segment as each bit rate layer and outputs a series of chunks in an encoded bit stream 225. Generally speaking, a chunk is a segment encoded as a particular bit rate layer. Thus, the encoder 220 can produce one or more chunks for each segment. In other embodiments, the encoder may encode the segment with less than all of the available bit rate layers. This may occur if, for example, a user defines a certain amount of time available for encoding, or conditions make certain bit rate layers un-necessary or undesirable.

As is well-understood in the art, the embodiment of FIG. 2 can be modified to encode a continuous media stream that is not divided into chunks. It is, however, desirable to be able to extract portions of the continuous media stream and to be able to logically define different portions of the media stream for extraction, if desired.

In certain embodiments, the encoding tool 200 can include a splitter (not shown) that splits the input video 205 into a separate video component and an audio component. In these embodiments, a separate segmenter, bit rate controller and encoder can be used to encode each of the video component and the audio component. The encoder for the video component can encode according to WMV or VC-1 format, MPEG-x format, H.26x format, or some other format. The encoder for the audio component can encode according to WAV, FLAC, MP3, WMA, or some other standard. Additionally, the segments for the video component and the segments for the audio component may be selected independently of each other. In this embodiment the segments of the video component may, but do not have to, comprise the same frames as the segments of the audio component. As described further below, the encoding tool 200 generates an index file that describes characteristics of the different segments that are created.

FIG. 3 shows multiple bit rates 1−N for a particular encoded segment generated by the encoding tool of FIG. 2. The content is identical at each bit rate, but the quality increases with higher bit rates. In the illustrated example, there are N bit rates shown, where N could be any number. In particular embodiments, N is equal to 4. Additionally, the media streams can be divided into segments (also called fragments or chunks). The fragments may range from two to five seconds each in certain embodiments, although any duration may be used. A particular example includes video segments that are 2 seconds in length and audio segments are 5 seconds in length. In the example of FIG. 3, the bit rates are substantially constant amounts (e.g., 1 kbps, 2 kbps, etc.).

FIG. 4 is an example of variable bit rates 400 that may also be used with any of the embodiments described herein and generated by the encoding tool of FIG. 2. Variable bit rates allocate a different amount of data to a scene based on complexity. Some scenes require a lower bit rate, such as dark scenes with low levels of movement. Other scenes, such as action scenes, require a higher bit rate because the scenes are more complex. A lower complexity scene can be seen between 0 and 50 seconds and has a small bit rate distribution between the media streams. The higher complexity scenes have a high amount of bit rate distribution as seen at about 100 seconds. In a case with such variance in the bit rates, although the bit rate of one media stream may, on average, be the highest, that media stream's bit rate may fall below the maximum bit rate for other media streams. For purposes of illustration, the bit rates are classified as index 1, 2, 3, . . . N. For example, the bit rates for index 1 and 2 are shown at 402, 404, respectively. At a time shown at 406, the bit rate for index 1 is about 1050 kbps. However, as can be seen at a time shown at 404, index 2 is about 2000 kbps, which is a higher bit rate than index 1 at time 406. Thus, although index 1 is always higher than index 2 at any particular point of time, over the entire time period, index 2 can peak above values of index 1.

FIG. 5 is a flowchart of a method for generating an index associated with multiple bit rates of a media stream. In process block 500, a media stream is input into an encoding tool (e.g., encoding tool 200) in order to generate multiple media streams at multiple bit rates. The media streams are fragmented using logical or actual entry points (process block 502). Thus, the media streams may be divided into separate chunks of data or the media streams may be continuous with logical entry points into the media stream in order to divide the media stream into virtual fragments. In process block 504, an index table is generated by the encoding tool that describes the different bit rates and how the media stream is divided.

FIG. 6 illustrates an application 602 loaded on the playback device 104 for rendering content. The application 602 may be run on any desired playback device that renders a media stream, such as a gaming console, a cellular phone, a personal digital assistant, in a browser on a computer, etc. The application can include a network communication module 604, a source filter 606, a media pipeline 608, a UI rendering module 610, and a heuristics module 612. The network communication module 604 generally includes software to communicate with a network server from which the media content is streamed. Thus, it is a downloader to obtain the media stream from the network. One example network communication module includes software for implementing a hypertext transfer protocol when communicating with a Web server. Other well-known protocols can be used depending on the playback device. The network communications module chooses an appropriate bit rate of a media stream as directed by the heuristics module. The source filter 606 can be coupled to the network communication module in order to receive audio and video content from the network. The source filter extracts the core media data (by parsing the file, if necessary) and splits the audio and video into two streams for use by the media pipeline. An example media pipeline 608 is shown in FIG. 9 and is described more fully below. The source filter 606 can be included in the media pipeline or separated there from. In any event, the media pipeline decodes the audio and video streams and provides the decoded streams to the UI rendering module 610 for display. Alternatively, the media pipeline 608 can be coupled to a storage device (not shown) that persistently stores the uncompressed data stream. Any variety of media pipelines may be used. The heuristics module 612 monitors the network (via the network communication module 604) and the source filter to make intelligent decisions about which bit rate to request from the server in order to minimize glitches that are rendered on the playback device. Once empirical data is analyzed from the media pipeline 608 and the network, the heuristics module 612 can use the index file 614 in order to decide which media stream (i.e., which bit rate and/or quality) to download from the network to minimize glitches. The index file 614 describes the available media-stream options for the playback device from which the heuristics module can choose.

FIG. 7 illustrates another possible environment used to render content on the playback device 104. The lowest layer (not shown) is an operating system executing on the playback device. A platform 702 is an executable file that is downloaded one time from a web server and remains resident on the playback device 104. The platform 702 includes a media pipeline 704 that is explained further below in FIG. 9, a simple source module 706, and a UI rendering module 708 used to render the media stream. A download management program 710 is typically downloaded each time a website is accessed and includes a managed source 712 and a heuristics module 714, which include the intelligence to make decisions about a desired bit rate to download from the host device 102. The purpose of the simple source 706 is to communicate with the managed source 712. Both the managed source 712 and the heuristics module 714 are described further below. The download management program 710 and platform 702 are part of an application 720 that is loaded in a browser 722.

FIG. 8 illustrates a generalized example of a suitable computing environment 800 in which several of the described embodiments may be implemented. The computing environment 800 is not intended to suggest any limitation as to scope of use or functionality, as the techniques and tools may be implemented in diverse general-purpose or special-purpose computing environments.

With reference to FIG. 8, the computing environment 800 includes at least one processing unit 810 and memory 820. Similar computing devices may be used as either the host device 102 or the playback device 104. This most basic configuration 830 is included within a dashed line. The processing unit 810 executes computer-executable instructions and may be a real or a virtual processor. In a multi-processing system, multiple processing units execute computer-executable instructions to increase processing power. The memory 820 may be volatile memory (e.g., registers, cache, RAM), non-volatile memory (e.g., ROM, EEPROM, flash memory, etc.), or some combination of the two.

A computing environment may have additional features. For example, the computing environment 800 includes storage 840, one or more input devices 850, one or more output devices 860, and one or more communication connections 870. An interconnection mechanism (not shown) such as a bus, controller, or network interconnects the components of the computing environment 800. Typically, operating system software (not shown) provides an operating environment for other software executing in the computing environment 800, and coordinates activities of the components of the computing environment 800.

The storage 840 may be removable or non-removable, and includes magnetic disks, magnetic tapes or cassettes, CD-ROMs, DVDs, or any other medium which can be used to store information and which can be accessed within the computing environment 800. The storage 840 stores instructions for the software 880 implementing the video encoder and/or decoder.

The input device(s) 850 may be a touch input device such as a keyboard, mouse, pen, or trackball, a voice input device, a scanning device, or another device that provides input to the computing environment 800. The input device(s) 850 may be a sound card, video card, TV tuner card, or similar device that accepts audio or video input in analog or digital form, or a CD-ROM or CD-RW that reads audio or video samples into the computing environment 800. The output device(s) 860 may be a display, printer, speaker, CD-writer, or another device that provides output from the computing environment 800.

The communication connection(s) 870 enable communication over a communication medium to another computing entity. The communication medium conveys information such as computer-executable instructions, audio or video input or output, or other data in a modulated data signal. A modulated data signal is a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired or wireless techniques implemented with an electrical, optical, RF, infrared, acoustic, or other carrier.

The techniques and tools can be described in the general context of computer-readable media. Computer-readable media are any available media that can be accessed within a computing environment. By way of example, and not limitation, with the computing environment 800, computer-readable media include memory 820, storage 840, communication media, and combinations of any of the above.

The techniques and tools can be described in the general context of computer-executable instructions, such as those included in program modules, being executed in a computing environment on a target real or virtual processor. Generally, program modules include routines, programs, libraries, objects, classes, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The functionality of the program modules may be combined or split between program modules as desired in various embodiments. Computer-executable instructions for program modules may be executed within a local or distributed computing environment.

For the sake of presentation, the detailed description uses terms like “produce” and “encode” to describe computer operations in a computing environment. These terms are high-level abstractions for operations performed by a computer, and should not be confused with acts performed by a human being. The actual computer operations corresponding to these terms vary depending on implementation. Generally, the computing environment 800 can be used as the playback device 104.

FIG. 9 shows an example of the media pipeline 904 in more detail. The illustrated media pipeline is only an example of a possible media pipeline that can be used. In this example, a source filter 900 is included in the media pipeline and is coupled to the network to receive audio and video content from the network. The source filter can extract the core media data (by parsing the file, if necessary) and can split the audio and video into two streams. Two decoders 906, 908 can be used to decompress the encoded audio and video, respectively. Two transform modules 910, 912 can transform the decompressed audio and video signals. The transform operations can include a variety of operations, such as changing color space, changing scale, adding special effects, etc. Finally, sinks 914, 916 can be used to transmit the content to the audio and video drivers, respectively.

FIG. 10 shows an example of the download management program 710 in more detail. An index file 1000 is provided by the host and generally describes the different bit rates for the media streams that are available from the network and an address (e.g., URL) where to obtain the source content. In general, the managed source 712 reads data from the network (e.g., Internet), parses the index file 1000 that describes the content, parses the file received from the network (e.g., remove header information), communicates with the heuristics module 714 about which bit rate to download next, and maintains an input buffer. The heuristics module 714 instructs the managed source 712 which bit rate to pull next based on empirical data, such as one or more of the following:

1) current and historic bandwidth levels;

2) current and historic buffer levels; and

3) capabilities of the playback device.

An example index file can have separate sections for video and audio and describe the different bit rates that are available to pull from the host. It also can include the URLs, the duration of the content segments, quality information, the size of the files, the number of content segments, position in time of the content segments, the media attributes, etc. In sum, the index file includes information about the time-varying properties of the encoded media streams. An example index file is as follows:

manifest <MediaIndex MajorVersion=“0” MinorVersion=“1”>   <Attribute Name=“XCP_MS_UINT64_DURATION” Value=“30”/> <StreamIndex   Type = “video”   Subtype = “WVC1”   Chunks = “15”   Url = “{1}/chunk_{1}_{0}.vid” >   <Bitrate Kbps = “200”/>   <Bitrate Kbps = “700”/>   <Bitrate Kbps = “1500”/>   <Attribute Name=“XCP_MS_UINT32_4CC” Value=“WVC1”/>   <Attribute Name=“XCP_MS_UINT32_WIDTH” Value=“720”/>   <Attribute Name=“XCP_MS_UINT32_HEIGHT” Value=“480”/>   <Attribute Name=“XCP_MS_BLOB_VIDEO_CODEC” Value=“270000010FCBEE1670EF8A16783BF180C9089CC4AFA11C0000010E1207F840”/>   <c n=“0” d=“20020000”/><c n=“1” d=“20020000”/><c n=“2” d=“20020000”/><c n=“3” d=“20020000”/><c n=“4” d=“20020000”/><c n=“5” d=“20020000”/><c n=“6” d=“20020000”/><c n=“7” d=“20020000”/><c n=“8” d=“20020000”/><c n=“9” d=“20020000”/>   <c n=“10” d=“20020000”/><c n=“11” d=“20020000”/><c n=“12” d=“20020000”/><c n=“13” d=“20020000”/><c n=“14” d=“20020000”/> </StreamIndex> <StreamIndex   Type = “audio”   Subtype = “WMA”   Chunks = “15”   Url = “audio/chunk_{1}_{0}.aud”   Language=“en-us” >   <Bitrate Kbps = “700”/>   <Attribute Name=“XCP_MS_BLOB_WAVEFORMATEX” Value=“6101020044AC0000853E00009D0B10000A00008800000F0000000000”/>   <c n=“0” d=“20630000”/><c n=“1” d=“20810000”/><c n=“2” d=“19390000”/><c n=“3” d=“20430000”/><c n=“4” d=“18800000”/><c n=“5” d=“20210000”/><c n=“6” d=“20440000”/><c n=“7” d=“19500000”/><c n=“8” d=“21370000”/><c n=“9” d=“19040000”/>   <c n=“10” d=“19960000”/><c n=“11” d=“20610000”/><c n=“12” d=“18870000”/><c n=“13” d=“21360000”/><c n=“14” d=“19510000”/> </StreamIndex> </MediaIndex>

The content is divided into segments (called chunks) that are generally 2-5 seconds each. The chunks are available at multiple bit rates. As already discussed, the chunks may be physically divided segments or virtually divided segments (in the case of a continuous stream). After a predetermined period of time, the quality and bit rate are reevaluated to ensure a glitch-free display of the media stream.

The designation of “bit rates” refers to the bit rates available for the media stream. The “attribute” names can provide information used by the decoder in the media pipeline in order to decode the media stream. One example is that the attributes can be initialization information for the decoder. There can be different sections in the index file for “video” and “audio”, so that the chunks are described independently for each. The designation of “n=” refers to a chunk number. The chunks can be numbered sequentially. The designation of “d=” following each chunk number refers to the duration of the chunk. As can be seen, the chunks are of varying duration but are approximately equal in length. Other characteristics of the media stream can easily be inserted into the index file, such as the size of files associated with the chunks or the duration of the entire media segment. An additional characteristic is also resolution that can be useful to proper rendering. The illustrated index file is only an example and not all of the data elements described need to be used. Indeed, one or more of any of the data elements can be used.

Another example index file is as follows:

<MediaIndex MajorVersion=“0” MinorVersion=“3”> <Attribute Name=“XCP_MS_UINT64_DURATION_HNS” Value=“1169500000”/> <StreamIndex Type=“Video” SubType=“WVC1” Url=“mbr/JennaEasyHD_1280×720_30fps_{1}_{0}.vid” Chunks=“62” Bitrates=“12”> <Bitrate n=“0” Kbps=“3960” w=“1280” h=“720”/> <Bitrate n=“1” Kbps=“2083” w=“1280” h=“720”/> <Bitrate n=“2” Kbps=“1813” w=“1280” h=“720”/> <Bitrate n=“3” Kbps=“1564” w=“1280” h=“720”/> <Bitrate n=“4” Kbps=“1396” w=“1280” h=“720”/> <Bitrate n=“5” Kbps=“1140” w=“1280” h=“720”/> <Bitrate n=“6” Kbps=“925” w=“600” h=“400”/> <Bitrate n=“7” Kbps=“781” w=“600” h=“400”/> <Bitrate n=“8” Kbps=“597” w=“600” h=“400”/> <Bitrate n=“9” Kbps=“455” w=“600” h=“400”/> <Bitrate n=“10” Kbps=“349” w=“600” h=“400”/> <Bitrate n=“11” Kbps=“249” w=“600” h=“400”/> <Attribute Name=“XCP_MS_UINT32_4CC” Value=“WVC1”/> <Attribute Name=“XCP_MS_UINT32_WIDTH” Value=“1280”/> <Attribute Name=“XCP_MS_UINT32_HEIGHT” Value=“720”/> <Attribute Name=“XCP_MS_BLOB_VIDEO_CODEC” Value=“250000010fd3fe27f1678a27f859f180c8800000010e5a0040”/> <c n=“0” d=“20020000”><f n=“0” s=“839” q=“4930”/><f n=“1” s=“413” q=“2421”/><f n=“2” s=“367” q=“2148”/><f n=“3” s=“322” q=“1885”/><f n=“4” s=“290” q=“1696”/><f n=“5” s=“232” q=“1355”/><f n=“6” s=“184” q=“1076”/><f n=“7” s=“164” q=“953”/><f n=“8” s=“124” q=“721”/><f n=“9” s=“99” q=“575”/><f n=“10” s=“79” q=“454”/><f n=“11” s=“58” q=“334”/></c> <c n=“1” d=“22020000”><f n=“0” s=“837” q=“4761”/><f n=“1” s=“435” q=“2469”/><f n=“2” s=“397” q=“2255”/><f n=“3” s=“342” q=“1941”/><f n=“4” s=“308” q=“1748”/><f n=“5” s=“251” q=“1422”/><f n=“6” s=“194” q=“1099”/><f n=“7” s=“168” q=“946”/><f n=“8” s=“130” q=“731”/><f n=“9” s=“108” q=“605”/><f n=“10” s=“88” q=“494”/><f n=“11” s=“65” q=“359”/></c>

This index file includes additional information about each chunk. As already described above, “n” is the chunk number and “d” is the duration of the chunk. Another feature of the index file is that it can provide the size of a chunk, which is shown by use of a designation “s=”. The “q” designation represents each chunk's average quality. The average quality of a chunk can be calculated during encoding. In the particular example shown, the higher quality number generally means less information is lost due to video compression. As described further below, the heuristics module makes a determination based on a number of factors, such as empirical data of the playback, which bit rate to choose. Quality levels can also be considered into the decision. For example, quality information allows intelligent decisions about accepting lower bit rates for low quality content in order to reserve bandwidth for higher bit rates for high quality content. For example, low bit rates can be used for dark scenes that have little motion (where high quality might not necessarily be visually different than low quality) in favor of using high bit rates for scenes that are complex with a lot of motion.

Any of the described index files can be represented as an XML file with the specific schema, potentially, with a simple encoding to hide clear text. It can contain media level attributes (e.g. total playback duration), and description of individual streams. Stream descriptions can include media stream-specific information, such as type of the stream (e.g. video, audio), encoding and other codec information (e.g. fourCC code, width, height), available bitrates, and information on individual media segment represented by chunks of different available bitrates (e.g. segment duration, chunk sizes). Also, the stream description can include information that allows production of individual chunks URLs for download, which is normally a text pattern that includes calculated fields based on chunk number, chunk bitrate, chunk stream and stream type.

FIG. 11 shows a flowchart of a method for using an index file to make intelligent streaming choices. In process block 1100, an index file can be received from the network. For example, if a user clicks on a thumbnail on a browser, the index file can be retrieved first. In process block 1102, the index file is used to make decisions about which media stream to download. For example, the playback device can download any one of multiple (e.g., four) different media streams having different bit rates. Thus, the index file can be used to make intelligent choices about which stream to receive in order to provide a glitch-free experience. The index file is, therefore, a representation of data to enable advanced streaming scenarios. So that the full URL is not needed for each chunk, the index file can include a URL definition or template that enables the playback device to build the URL. An example definition is URL=“{1}/chunk_(—){1}_(—){0}.vid”, wherein the “1” defines the bit rate and “0” is the chunk number.

One desire is that by using the index file, the playback device can make intelligent decisions about which stream of content to pull from the host. The intelligent decisions include taking into consideration one or more of the following:

1) fast start-up;

2) adapting bandwidth to the network; and

3) adapting bandwidth to the client computer.

By making intelligent choices, the playback can minimize or eliminate glitches. A playback system is glitch free when the renderer does not run out of data to play. Another reason for a glitch is that the content is not being displayed at the rate it was authored. Once started, the player loads the index file and initializes itself using the data from the index file, while the first chunks are being downloaded.

FIG. 12 is a flowchart of a method for determining which media stream to download based, in part, on quality. Such a determination is often used in conjunction with variable bit rates. Variable bit rates relate to content that is not encoded at a fixed bit rate. But variable bit rates provide additional challenges in that if the heuristics module selected the second level of bit rates, it may be a different rate than the second level was at a previous point in time. In such a case, it is possible to allocate lower bandwidth for low complexity scenes (e.g., low motion) and higher bandwidth for high complexity (e.g., high motion) scenes. Indeed, low quality scenes can be utilized by lowering the bit rate in order to reach a high buffer level. Then for high quality scenes, a bit rate can be used that is higher than the available bandwidth. The high quality scene can take longer to download, but with the buffer at a high level, the playback device has sufficient time to download the high quality segments.

In FIG. 12 is a flowchart of a method is shown for choosing which media stream to download from a server computer using buffer levels and quality of the media stream being displayed. In process block 1200, the buffer level of the playback device and quality are monitored. In process block 1202, based on the monitoring of the buffer level and quality, the heuristics module makes intelligent choices about which media stream to request from the server. In process block 1204, the playback device receives the media stream from the server in order to provide a display with minimized glitches.

FIG. 13 is a flowchart of a method showing how both quality and buffer levels are used to determine a next chunk of a media stream to download. In process block 1300, the quality level is selected for the next media data (e.g., chunk) to download. In process block 1302, a determination is made whether the quality level could result in the buffer on the playback device to fall below a predetermined threshold (e.g., 5 seconds of playback). If so, decision block 1304 is answered in the affirmative and a new quality level is dynamically chosen (process block 1306). If the buffer levels will be maintained above the predetermined threshold, then in process block 1308, the media stream (e.g., a chunk) is downloaded from the server.

FIG. 14 provides a detailed example of a particular embodiment that can be used by the heuristic module in order to render content. Other examples can be used. The algorithm can be designed to select a bit rate stream for the next playback chunk. Some of the goals can include:

1) Provide a glitch-free experience so that the client playback device does not run out of data in its buffer while streaming.

2) Use the available network bandwidth to deliver the highest quality audio/video experience.

3) Provide consistent video quality when the user's bandwidth is stable.

First, it is desirable to obtain the current user bandwidth (e.g., bits per second) and the current buffer level (e.g., by milliseconds). In order to find the best sustainable quality (i.e., the target quality), it is desirable to predict the end buffer size and minimum buffer size for a predetermined number of chunks (e.g., 60 chunks). This predetermined number can be configurable. Assuming each chunk is 2 seconds long, the 60 chunks results in 120 seconds of video playback (of course other time durations and chunk numbers can be used). Predicting the end buffer and minimum buffer size ensures the client has a safe buffer for glitch-free media playback. Looking ahead for a predetermined number of chunks allows the end-user to see consistent video qualities for the next few minutes. Once the target quality is obtained, a selection is made on which media stream to download depending on which media stream has quality that most closely matches the target quality. The source filter can then download the selected chunk for future playback. This procedure is repeated for each chunk which has a different time during playback so that if the bandwidth changes, the source filter can dynamically choose the appropriate chunks for later playback.

The following shows example code illustrating how to select the next video/audio chunk.

Function PredictBuffer( _in bandwidth, _in ProposedQuality, _out minimumbuffer, _out endbuffer ) {   endbuffer = Current buffer size   minimumbuffer = endbuffer;   for( chunkindex = currentindex to next 60 chunks)   {     scan all streams for chunkindex, find the chunk with a nearest video quality to ProposedQuality     endbuffer = Endbuffer + (chunkduration −     ( chunksize/bandwidth ))     if( endbuffer < minimumbuffer )       minimumbuffer = endbuffer;   } }

In process block 1400, the variables for sustainable quality and nonsustainable quality are initialized. In process block 1402, a prediction is made for the buffer size. A midpoint between the sustainable and nonsustainable variables is used. In decision block 1404, if the minimum buffer size is more than a first predetermined period of time (e.g., 5 seconds) and the end buffer is greater than a second predetermined period of time (e.g., 15 seconds) then in block 1406, the quality is sustainable and the variable for sustainable quality is calculated as the midpoint between the nonsustainable and the sustainable variables. If decision block 1404 is answered in the negative, then in process block 1408, the quality is not sustainable and the variable for non-sustainability is set as the midpoint between the variables for sustainable and nonsustainable. In decision block 1410, a check is made to determine if the variable for non-sustainability less sustainability is greater than 1. If no, then the sustainable quality variable is used indicating that the two variables are close together. If yes, then the procedure starts over again in process block 1402.

Thus, an iterative process is used to determine the next chunk of data to download that has target quality. The goal is to keep the quality the same for a predetermined number of chunks to keep video quality stable.

Returning briefly to FIG. 4, the quality manager can decide to choose a lower quality bit rate during the period between times 0-50 seconds because the bit rate distribution is low. Thus, when bit rate distribution is low, the highest bit rate requires more time to download, but does not offer much higher quality than streams with a lower bit rate. On the other hand, at time 100 seconds, there is a wide distribution of bit rates and it may be desirable to select the highest bit rate to ensure high quality. This highest bit rate may exceed the available bandwidth of the network, but the quality manager sacrifices by choosing to conserve time by downloading lower bit rates than the available bandwidth during low complexity scenes so that more time can be spent downloading higher complexity scenes. Thus, the quality manager makes intelligent decisions to maintain relatively constant quality by downloading a media stream that is lower than it is capable of downloading during low-complexity scenes to conserve bandwidth for higher complexity scenes. By so doing, the bit rates that exceed the available bandwidth can be used.

FIG. 15 is a flowchart of a method regarding how the heuristics module chooses a bit rate to download based on buffer levels. In process block 1500, the playback device 104 is capable of pulling content from a server at any one of multiple bit rates over the Internet. In process block 1502, the heuristics module monitors the buffer level that is stored on the playback device (e.g., the buffer can be maintained in the managed source 712). There are variations in the rate at which data is received from the network, due to noise, etc. Thus, it is desirable to ensure that the buffer in maintained at a level so that the renderer does not run out of data and create a glitch. The buffer is maintained in a safety zone having a high and low threshold. If the buffer begins to drop due to network bandwidth, then a lower rate can be selected to return the buffer to the safety zone. If the buffer is full, then the heuristics module can select a higher bit rate to optimize quality. In process block 1504, the heuristics module selects the bit rate so that the buffer level is maintained in the safety zone between high and low limits.

There are multiple options for monitoring buffer levels including monitoring the number of bytes in the buffer and monitoring the amount of time remaining to render. It is desirable at start-up to select a low bit rate in order for the buffer to reach the safety zone. After that, the selected bit rate can be increased to improve quality.

FIG. 16 is a graph showing the buffer levels as a function of time. A slope 1602 is used to determine the rate at which the buffer levels are rising and falling. Based on this slope, a determination can be made on the next bit rate to download. For example, if the slope is decreasing rapidly, it may be desirable to drop the bit rate more quickly. In the specific example of FIG. 16, the high and low limits are shown as a duration of time remaining to render (i.e., 17 and 12 seconds). If the buffer is at the maximum level or above, higher quality chunks can be downloaded for future rendering because the playback device is not struggling to keep up. Conversely, if the buffer is at the lower limit or below, lower quality chunks can be downloaded in order to increase the buffer levels. Keeping the buffer between threshold limits ensures glitches are minimized or eliminated.

To increase the bit rate, the heuristics module can also take into account the historic bit rate that was acceptable in addition to the buffer levels. In order to maintain the historic data, the heuristics module can monitor the time and size of a file that was downloaded in order to determine the actual bandwidth from the client perspective.

In view of the many possible embodiments to which the principles of the disclosed invention may be applied, it should be recognized that the illustrated embodiments are only preferred examples of the invention and should not be taken as limiting the scope of the invention. Rather, the scope of the invention is defined by the following claims. We therefore claim as our invention all that comes within the scope of these claims. 

1. A method for rendering a media stream on a playback device, comprising: using an index file that describes characteristics of a media stream to make logical decisions about which bit rate for the media stream to choose in order to minimize glitches when the chosen media stream is rendered on the playback device; receiving the chosen media stream from the network; and rendering the chosen media stream on the playback device with minimized glitches.
 2. The method of claim 1, wherein characteristics described include the bit rate, fragment numbers, duration for fragments of the media streams, and network addresses of the media streams.
 3. The method of claim 1, wherein the different bit rates for the media stream include separate bit rates for audio and video.
 4. The method of claim 1, wherein the media stream is divided into fragments of substantially equal time duration.
 5. The method of claim 4, wherein the index file describes at least one of the following characteristics of the media stream: the bit rate, the duration of the fragments, and the quality of the fragments.
 6. The method of claim 1, wherein the index file includes attributes used in a media pipeline in decoding the media stream.
 7. The method of claim 1, further including encoding the media stream on a server computer and generating the index file on the server that defines the media stream as having multiple logical or actual entry points.
 8. The method of claim 1, wherein the playback device includes one of the following: a computer, a mobile phone, a gaming console, and a television; and wherein the network is the Internet.
 9. The method of claim 1, wherein the bit rates for the media stream are at substantially constant bit rates or variable bit rates.
 10. The method of claim 1, wherein making logical decisions includes adapting to a network bandwidth or adapting to an ability to render on the playback device.
 11. The method of claim 1, wherein making logical decisions includes using a heuristics module to monitor buffer levels and modifying the bit rate based on the buffer levels.
 12. A method for rendering a media stream on a playback device, comprising: generating a media stream at multiple bit rates using an encoder on a server computer; wherein the media stream is segmented with logical or actual entry points; and generating an index on the server computer describing the bit rates and segments.
 13. The method of claim 12, wherein each media stream at a different bit rate includes identical content but at varying levels of quality.
 14. The method of claim 12, wherein the bit rates are constant or variable.
 15. The method of claim 12, wherein the media stream is divided into fragments of a substantially fixed duration.
 16. A method of displaying content, comprising: receiving a request on a playback device to view a media stream; in response to the request, retrieving an index file describing fragments of the media stream and different bit rates available for the media stream; and using the index file to make decisions about which bit rate associated with the media stream to use.
 17. The method of claim 16, wherein the index file includes quality information associated with the fragments.
 18. The method of claim 16, wherein the bit rates are constant or variable bit rates.
 19. The method of claim 16, wherein the index file provides the duration of the fragments.
 20. The method of claim 16, wherein the decisions are made to minimize glitches on the playback device. 